﻿#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<assert.h>
#include<ctype.h>
#include<errno.h>
#include<float.h>
#include<iso646.h>
#include<limits.h>
#include<locale.h>
#include<math.h>
#include<stdarg.h>
#include<stddef.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<complex.h>
#include<stdbool.h>
#include<tgmath.h>
#include<signal.h>
#include<setjmp.h>
#include<inttypes.h>

//有一函数
//x             (x < 1)
//y = 2x - 1    (1 <= x < 10)
//3x - 11       (x >= 10)
//用scanf函输入x的值, 求y值
//int main() {
//    float x, y;
//    printf("Please enter x:");
//    scanf("%f", &x);
//    if (x < 1) {
//        y = x;
//    }
//    else if (x >= 1 && x < 10) {
//        y = 2 * x - 1;
//    }
//    else {
//        y = 3 * x - 11;
//    }
//    printf("y = %f\n", y);
//    return 0;
//}

//从键盘上输入一个正整数，判断这个数能否同时被3和5整除；
//int main() {
//    int num;
//    printf("请输入一个正整数：");
//    scanf("%d", &num);
//
//    if (num % 3 == 0 && num % 5 == 0) {
//        printf("%d 能同时被3和5整除\n", num);
//    }
//    else {
//        printf("%d 不能同时被3和5整除\n", num);
//    }
//
//    return 0;
//}

//设计算法输入一个四位正整数，将它们倒排，例如输入1234，输出4321。
//(提示：分别应用 / 求整数部分， % 求余数部分。例如7 / 5 = 1，7 % 5 = 2)。
//int main() {
//    int num, digit1, digit2, digit3, digit4, reversedNum;
//    // 输入四位正整数
//    printf("请输入一个四位正整数：");
//    scanf("%d", &num);
//    // 取个位数字
//    digit1 = num % 10;
//    // 取十位数字
//    digit2 = (num / 10) % 10;
//    // 取百位数字
//    digit3 = (num / 100) % 10;
//    // 取千位数字
//    digit4 = num / 1000;
//    // 组合成倒排后的数字
//    reversedNum = digit1 * 1000 + digit2 * 100 + digit3 * 10 + digit4;
//    // 输出倒排后的数字
//    printf("倒排后的数字为：%d\n", reversedNum);
//    return 0;
//}

//某公司的招聘条件如下：
//①Experience with C      
//②bachelor degree           
//③less than 30
//int main() {
//    char cExp;
//    char degree;
//    int age;
//    // 询问是否有 C 语言经验
//    printf("Do you have Experience with C? Press y/n\n");
//    scanf(" %c", &cExp);
//    cExp = tolower(cExp);
//    if (cExp == 'n') {
//        printf("We are so sorry to tell you...\n");
//        return 0;
//    }
//    // 询问是否有学士学位
//    printf("Do you have a bachelor degree? Press y/n\n");
//    scanf(" %c", &degree);
//    degree = tolower(degree);
//    if (degree == 'n') {
//        printf("We are so sorry to tell you...\n");
//        return 0;
//    }
//    // 询问年龄
//    printf("Please enter your age: ");
//    scanf("%d", &age);
//    if (age >= 30) {
//        printf("We are so sorry to tell you...\n");
//        return 0;
//    }
//    // 全部满足条件
//    printf("Welcome join us!\n");
//    return 0;
//}

//假设手机有两种收费方式，第一种是每分钟0.6元，无月租费；
//另一种是每分钟0.4元再收50元月租费，输入一个月打电话的时间(分钟)，
//判断那一种更省钱。
//int main() {
//    float call_time;
//    float cost1, cost2;
//
//    // 输入一个月的通话时间（分钟）
//    printf("请输入一个月打电话的时间（分钟）：");
//    scanf("%f", &call_time);
//
//    // 计算两种收费方式的费用
//    cost1 = 0.6 * call_time;          // 方式1：无月租，0.6元/分钟
//    cost2 = 0.4 * call_time + 50;     // 方式2：50元月租，0.4元/分钟
//
//    // 比较费用并输出结果
//    if (cost1 < cost2) {
//        printf("第一种收费方式更省钱\n");
//    }
//    else if (cost1 == cost2) {
//        printf("两种收费方式费用相同\n");
//    }
//    else {
//        printf("第二种收费方式更省钱\n");
//    }
//
//    return 0;
//}

//税收问题。假设某国家收税是分段计费，标准如下：
//在1万元以上部分收税20% ；
//5000 - 10000元部分收税10 % ；
//1000 - 5000元部分收税5 % ；
//1000元以下部分免税。
//根据输入的金额计算应缴纳的税金。
//如：某人收入是12000元，
//则应缴纳的税金为4000 * 5 % +5000 * 10 % +2000 * 20 %= 1100元
//int main() {
//    // 定义变量存储输入的金额和计算出的税金
//    float amount, tax = 0;
//
//    // 提示用户输入金额
//    printf("请输入金额：");
//    scanf("%f", &amount);
//
//    // 1000 - 5000 元部分收税 5%
//    if (amount > 1000) {
//        // 计算该区间的纳税部分，最多为 4000 元（5000 - 1000）
//        float part1 = (amount > 5000) ? 4000 : (amount - 1000);
//        tax += part1 * 0.05;
//    }
//
//    // 5000 - 10000 元部分收税 10%
//    if (amount > 5000) {
//        // 计算该区间的纳税部分，最多为 5000 元（10000 - 5000）
//        float part2 = (amount > 10000) ? 5000 : (amount - 5000);
//        tax += part2 * 0.1;
//    }
//
//    // 10000 元以上部分收税 20%
//    if (amount > 10000) {
//        // 计算该区间的纳税部分
//        float part3 = amount - 10000;
//        tax += part3 * 0.2;
//    }
//
//    // 输出应缴纳的税金
//    printf("应缴纳的税金为：%.2f 元\n", tax);
//
//    return 0;
//}

//分别用while、do - while、for语句编程，
//求数列前20项之和：2 / 1，3 / 2，5 / 3，8 / 5，13 / 8······
//int main() {
//    // 定义实变量，sum存储和，term存储每一项，a分子，b分母，c临时变量；i为计数器
//    float sum = 0, term, a = 2, b = 1, c;
//    int i = 1;
//    while (i <= 20) {
//        // 计算第i项
//        term = a / b;
//        // 累加
//        sum = sum + term;
//        // 更新分子分母
//        c = a + b;
//        b = a;
//        a = c;
//        // 计数器加1
//        i++;
//    }
//    // 输出两位精度的结果
//    printf("%.2f\n", sum);
//    return 0;
//}

//int main() {
//    float sum = 0, term, a = 2, b = 1, c;
//    int i = 1;
//    do {
//        term = a / b;
//        sum = sum + term;
//        c = a + b;
//        b = a;
//        a = c;
//        i++;
//    } while (i <= 20);
//    printf("%.2f\n", sum);
//    return 0;
//}

//int main() {
//    float sum = 0, term, a = 2, b = 1, c;
//    int i;
//    for (i = 1; i <= 20; i++) {
//        term = a / b;
//        sum = sum + term;
//        c = a + b;
//        b = a;
//        a = c;
//    }
//    printf("%.2f\n", sum);
//    return 0;
//}

//36块砖36人搬，男搬4女搬3，小孩2人搬1砖。要求一次全搬完，
//问男、女、小孩各若干（人）？
//int main() {
//    int x, y, z;
//    // 遍历x的可能取值
//    for (x = 1; x <= 9; x++) {
//        // 遍历y的可能取值
//        for (y = 1; y <= 12; y++) {
//            // 遍历z的可能取值（步长为2）
//            for (z = 2; z <= 36; z += 2) {
//                // 判断是否满足两个方程条件
//                if (x + y + z == 36 && 4 * x + 3 * y + z / 2 == 36) {
//                    // 输出满足条件的x、y、z值
//                    printf("男：%d 人，女：%d 人，小孩：%d 人\n", x, y, z);
//                }
//            }
//        }
//    }
//    return 0;
//}

//int main() {
//    int x, y, z;
//    int count = 0; // 用于计数解的数量
//
//    for (x = 0; x <= 9; x++) {       // 最多9个男人（4*9=36）
//        for (y = 0; y <= 12; y++) {  // 最多12个女人（3*12=36）
//            // 由总人数方程直接计算z，避免三重循环
//            z = 36 - x - y;
//
//            // 验证z是否为非负偶数，且满足搬砖方程
//            if (z >= 0 && z % 2 == 0 && (4 * x + 3 * y + z / 2 == 36)) {
//                printf("解 %d: 男=%d, 女=%d, 小孩=%d\n", ++count, x, y, z);
//            }
//        }
//    }
//    printf("共找到 %d 组解\n", count);
//    return 0;
//}

//某生产豪华游轮的造船厂，第一年生产3艘，从第二年开始，
//每年产量是前一年的产量减去半艘再翻一番，请问第10年产量多少艘？
//10年总产量多少艘？(要求必须使用for语句)
//int main() {
//    // 定义变量，current_year_output为当年产量，total_output为总产量，初始值为第一年的产量
//    float current_year_output = 3, total_output = 3;
//    int i;
//    // 使用for循环从第二年到第十年计算每年的产量和总产量
//    for (i = 2; i <= 10; i++) {
//        // 计算当年产量：前一年产量减去半艘再翻一番
//        current_year_output = (current_year_output - 0.5) * 2;
//        // 累加总产量
//        total_output += current_year_output;
//    }
//    // 输出第十年的产量和十年总产量，保留一位小数
//    printf("第10年产量：%.1f 艘\n", current_year_output);
//    printf("10年总产量：%.1f 艘\n", total_output);
//    return 0;
//}

//把一张10元的人民币兑换成2元和1元的纸币，
//请问有多少种兑换方法？输出所有的兑换方法
//int main() {
//    int two_yuan, one_yuan;
//    int count = 0;
//    // 遍历2元纸币的可能数量
//    for (two_yuan = 0; two_yuan <= 5; two_yuan++) {
//        // 计算1元纸币的数量
//        one_yuan = 10 - 2 * two_yuan;
//        // 输出兑换方法
//        printf("2元纸币：%d 张，1元纸币：%d 张\n", two_yuan, one_yuan);
//        // 兑换方法数加1
//        count++;
//    }
//    // 输出兑换方法的总数
//    printf("共有 %d 种兑换方法\n", count);
//    return 0;
//}

//参考例题3 - 23，写一程序输出以下图案：(要求必须使用循环)
//   *
//  ***
// *****
//*******
// *****
//  ***
//   *
//int main() {
//    int i, j, k;
//    // 上半部分图案（4行）
//    for (i = 1; i <= 4; i++) {
//        // 输出每行前面的空格
//        for (j = 1; j <= 4 - i; j++) {
//            printf("  ");
//        }
//        // 输出每行的*
//        for (k = 1; k <= 2 * i - 1; k++) {
//            printf("* ");
//        }
//        // 换行
//        printf("\n");
//    }
//    // 下半部分图案（3行）
//    for (i = 3; i >= 1; i--) {
//        // 输出每行前面的空格
//        for (j = 1; j <= 4 - i; j++) {
//            printf("  ");
//        }
//        // 输出每行的*
//        for (k = 1; k <= 2 * i - 1; k++) {
//            printf("* ");
//        }
//        // 换行
//        printf("\n");
//    }
//    return 0;
//}

//在3位自然数中，统计有2个位数相等，但3个数字不全相等的偶数的个数，
//并输出所有满足条件的数
//int main() {
//    int count = 0;
//    // 遍历所有三位自然数
//    for (int num = 100; num <= 999; num++) {
//        // 提取百位、十位、个位数字
//        int hundreds = num / 100;
//        int tens = (num / 10) % 10;
//        int units = num % 10;
//        // 判断是否为偶数
//        if (units % 2 != 0) {
//            continue;
//        }
//        // 判断是否有2个数字相等且3个数字不全相等
//        if ((hundreds == tens && hundreds != units) || (hundreds == units && hundreds != tens) || (tens == units && tens != hundreds)) {
//            // 输出满足条件的数
//            printf("%d ", num);
//            // 计数加1
//            count++;
//        }
//    }
//    // 输出满足条件的数的个数
//    printf("\n满足条件的数的个数为：%d\n", count);
//    return 0;
//}

//用筛法求1~1000之间的素数。
//eratosthenes筛法：
//1）	利用数组存放这1000个数；
//2）	挖掉第一个数1（令该数 = 0）；
//3）	2没被挖掉，挖掉后面所有2的倍数；
//4）	3没被挖掉，挖掉后面所有3的倍数；
//5）	4被挖掉，不执行任何操作；
//6）	5没被挖掉，挖掉后面所有5的倍数；
//7）	····直到最后一个数；
//8）	剩下的非0数就是素数。
//#define MAX 1000
//int main() {
//     定义数组存储1到1000的数
//    int numbers[MAX + 1];
//    int i, j;
//     初始化数组，numbers[i] = i
//    for (i = 1; i <= MAX; i++) {
//        numbers[i] = i;
//    }
//     挖掉1（令numbers[1] = 0）
//    numbers[1] = 0;
//     从2开始筛
//    for (i = 2; i <= MAX; i++) {
//         如果当前数未被挖掉
//        if (numbers[i] != 0) {
//             挖掉当前数的所有倍数
//            for (j = i * 2; j <= MAX; j += i) {
//                numbers[j] = 0;
//            }
//        }
//    }
//     统计素数个数并输出素数
//    int count = 0;
//    printf("1到1000之间的素数有：\n");
//    for (i = 2; i <= MAX; i++) {
//        if (numbers[i] != 0) {
//            printf("%d ", numbers[i]);
//            count++;
//             每行输出10个素数，方便查看
//            if (count % 10 == 0) {
//                printf("\n");
//            }
//        }
//    }
//    printf("\n1到1000之间共有 %d 个素数\n", count);
//    return 0;
//}

//2．编写程序输入一个字符串，删除字符串中的所有数字字符后输出此字符串。
//【算法提示】
//(1)定义一个一维字符数组；
//(2)输入一串测试字符；
//(3)依次判断数组中字符是否为数字(即 > ‘0’且 < ‘9’)；
//(4)若是则将后面所有字符依次往前移一位；
//(5)输出整个字符串。
//int main() {
//    // 定义一维字符数组
//    char str[100];
//    int i, j;
//    // 输入一串测试字符
//    printf("请输入一个字符串：");
//    scanf("%s", str);
//    // 依次判断数组中字符是否为数字
//    for (i = 0; str[i] != '\0'; i++) {
//        if (str[i] >= '0' && str[i] <= '9') {
//            // 若是数字字符，将后面所有字符依次往前移一位
//            for (j = i; str[j] != '\0'; j++) {
//                str[j] = str[j + 1];
//            }
//            // 因为删除了当前字符，所以i要减1，以便下一次循环检查当前位置（原下一个字符）
//            i--;
//        }
//    }
//    // 输出整个字符串
//    printf("删除数字字符后的字符串：%s\n", str);
//    return 0;
//}

//输入若干个整数存放在一维数组中，根据此数组构造两个数组a和b，
//要求a中存放数组x中所有的正数，b中存放数组中所有的负数，0舍弃，
//最后分别输出数组a和b
//#define MAX_SIZE 100
//int main() {
//    int x[MAX_SIZE], a[MAX_SIZE], b[MAX_SIZE];
//    int n, i, a_count = 0, b_count = 0;
//    // 输入整数个数
//    printf("请输入整数的个数：");
//    scanf("%d", &n);
//    // 输入数组元素
//    printf("请输入%d个整数：\n", n);
//    for (i = 0; i < n; i++) {
//        scanf("%d", &x[i]);
//    }
//    // 分离正数和负数到数组a和b
//    for (i = 0; i < n; i++) {
//        if (x[i] > 0) {
//            a[a_count++] = x[i];
//        }
//        else if (x[i] < 0) {
//            b[b_count++] = x[i];
//        }
//    }
//    // 输出数组a
//    printf("数组a（正数）：");
//    for (i = 0; i < a_count; i++) {
//        printf("%d ", a[i]);
//    }
//    printf("\n");
//    // 输出数组b
//    printf("数组b（负数）：");
//    for (i = 0; i < b_count; i++) {
//        printf("%d ", b[i]);
//    }
//    printf("\n");
//    return 0;
//}

//#include <stdio.h>
//void main()
//{
//    printf("Programming is Fun！\n");
//}


//#include <stdio.h>
//void main()
//{
//    int c;
//    printf("Input a num:");
//    scanf("%d", &c);
//    printf("The number is:%d\n", c);
//}

//#include<stdio.h>
//void main()
//{
//    int a = -1, b = 98;
//    double x = 152.6752445;
//    printf("a=%d, %ld, %u, %o, %x\n", a, a, a, a, a);
//    printf("b=%d, %5d, %-5d,%c,%5c,%-5c\n", b, b, b, b, b, b);
//    printf("x=%f, %e\n", x, x);
//    printf("x=%.2f, %15.2f, %-15.2f, %15.9f\n", x, x, x, x);
//}

//4．10个小孩围成一圈分糖，老师分给第1个孩子10块，第2个孩子2块，第3个孩子8块，
//第4个孩子22块，第5个孩子16块，第6个孩子4块，第7个孩子10块，第8个孩子6块，
//第9个孩子14块，第10个孩子20块，
//然后所有的小孩同时将自己手中的糖分一半给右边的小孩，
//糖块数为奇数的人可向老师再要一块。
//问经过这样几次调整后大家手中的糖的块数都一样？
//每人各有多少块糖。
//(注：第i个小朋友的右边是第i - 1个小朋友，第1个小朋友的右边是第10个小朋友)
//#include <stdio.h>
//
//int isAllEqual(int c[]) {
//    for (int i = 1; i < 10; i++) if (c[i] != c[0]) return 0;
//    return 1;
//}
//
//int main() {
//    int c[10] = { 10,2,8,22,16,4,10,6,14,20 }, t[10], cnt = 0;
//    while (!isAllEqual(c)) {
//        for (int i = 0; i < 10; i++)
//            t[i] = c[i] / 2 + c[(i + 1) % 10] / 2;
//        for (int i = 0; i < 10; i++)
//            if (t[i] % 2) t[i]++;
//        for (int i = 0; i < 10; i++)
//            c[i] = t[i];
//        cnt++;
//    }
//    printf("%d %d", cnt, c[0]);
//    return 0;
//}


//假设在2 * 10的二维数组中存放了数据，其中各行的元素构成一个整数，
//如第一行元素构成整数1234507000。编写程序比较两行元素构成的整数大小。
//(规则：从高位起逐个比对应位数，若每位均相等，则两数相等；
//若遇到第一个不相等的数字，则数字大者为大)
//int main() {
//    // 定义 2*10 的二维数组并初始化
//    int arr[2][10] = {
//        {1, 2, 3, 4, 5, 0, 7, 0, 0, 0},
//        {1, 2, 3, 7, 4, 2, 6, 0, 0, 0}
//    };
//
//    int i;
//    // 从高位（数组第一个元素）开始逐个比较对应位数
//    for (i = 0; i < 10; i++) {
//        if (arr[0][i] > arr[1][i]) {
//            printf("第一行构成的整数更大\n");
//            break;
//        }
//        else if (arr[0][i] < arr[1][i]) {
//            printf("第二行构成的整数更大\n");
//            break;
//        }
//    }
//    // 如果所有对应位都相等，说明两个整数相等
//    if (i == 10) {
//        printf("两行构成的整数相等\n");
//    }
//
//    return 0;
//}


//输入一个5行5列的矩阵，计算该矩阵最外圈元素之和
//int main() {
//    // 定义 5x5 的矩阵
//    int matrix[5][5];
//    // 用于存储最外圈元素之和
//    int sum = 0;
//
//    // 输入矩阵元素
//    printf("请输入 5 行 5 列的矩阵元素：\n");
//    for (int i = 0; i < 5; i++) {
//        for (int j = 0; j < 5; j++) {
//            scanf("%d", &matrix[i][j]);
//        }
//    }
//
//    // 计算最外圈元素之和
//    // 第一行（行索引为 0）所有元素
//    for (int j = 0; j < 5; j++) {
//        sum += matrix[0][j];
//    }
//    // 最后一行（行索引为 4）所有元素
//    for (int j = 0; j < 5; j++) {
//        sum += matrix[4][j];
//    }
//    // 第一列（列索引为 0）除去第一行和最后一行的元素
//    for (int i = 1; i < 4; i++) {
//        sum += matrix[i][0];
//    }
//    // 最后一列（列索引为 4）除去第一行和最后一行的元素
//    for (int i = 1; i < 4; i++) {
//        sum += matrix[i][4];
//    }
//
//    printf("矩阵最外圈元素之和为：%d\n", sum);
//
//    return 0;
//}

//从键盘上输入一些字符串（以”$$$”为结束标志）。
//然后统计每个字符串的出现次数。最后按输入顺序输出各个单词及其对应的出现次数。
//#define MAX_STRINGS 100
//#define MAX_LEN 50
//
//int main() {
//    char strings[MAX_STRINGS][MAX_LEN];
//    int counts[MAX_STRINGS] = { 0 };
//    int numStrings = 0;
//    char input[MAX_LEN];
//
//    printf("请输入字符串（以\"$$$\"结束）：\n");
//    while (1) {
//        scanf("%s", input);
//        if (strcmp(input, "$$$") == 0) {
//            break;
//        }
//
//        int found = 0;
//        for (int i = 0; i < numStrings; i++) {
//            if (strcmp(strings[i], input) == 0) {
//                counts[i]++;
//                found = 1;
//                break;
//            }
//        }
//
//        if (!found && numStrings < MAX_STRINGS) {
//            strcpy(strings[numStrings], input);
//            counts[numStrings] = 1;
//            numStrings++;
//        }
//    }
//
//    printf("\n输出结果：\n");
//    for (int i = 0; i < numStrings; i++) {
//        printf("%s %d\n", strings[i], counts[i]);
//    }
//
//    return 0;
//}


//1．编写一个函数prt(c, n)，重复打印给定的字符c, n次。在主函数中调用prt(c, n)函数，打印一个直角三角形。
//如：prt(*, 6)的结果如下：
//*
//**
//***
//****
//*****
//******
//void prt(char c, int n) {
//    for (int i = 0; i < n; i++) {
//        printf("%c", c);
//    }
//}
//
//int main() {
//    int rows = 6;
//    for (int i = 1; i <= rows; i++) {
//        prt('*', i);
//        printf("\n");
//    }
//    return 0;
//}

//写四个函数分别用于计算圆周长、圆面积、圆柱表面积，圆柱体积，在main函数中完成测试。
//#define PI 3.14159
//double circlePerimeter(double r) {
//    return 2 * PI * r;
//}
//
//double circleArea(double r) {
//    return PI * r * r;
//}
//
//double cylinderSurfaceArea(double r, double h) {
//    return 2 * circleArea(r) + circlePerimeter(r) * h;
//}
//
//double cylinderVolume(double r, double h) {
//    return circleArea(r) * h;
//}
//
//int main() {
//    double r, h;
//    printf("请输入圆的半径：");
//    scanf("%lf", &r);
//    printf("请输入圆柱的高：");
//    scanf("%lf", &h);
//    printf("圆周长：%.2f\n", circlePerimeter(r));
//    printf("圆面积：%.2f\n", circleArea(r));
//    printf("圆柱表面积：%.2f\n", cylinderSurfaceArea(r, h));
//    printf("圆柱体积：%.2f\n", cylinderVolume(r, h));
//    return 0;
//}

//根据以下公式求π的近似值，直到最后一项的绝对值小于10 - 5为止
//double calculatePi() {
//    double sum = 0.0;
//    int n = 1;
//    double term;
//    while (1) {
//        term = 1.0 / (n * n);
//        if (fabs(term) < 1e-5) {
//            break;
//        }
//        sum += term;
//        n++;
//    }
//    return sqrt(6 * sum);
//}
//
//int main() {
//    double pi = calculatePi();
//    printf("π的近似值：%.6f\n", pi);
//    return 0;
//}

//用递归方法计算 的值，n的值由键盘输入
//int cubeSum(int n) {
//    if (n == 1) {
//        return 1;
//    }
//    return n * n * n + cubeSum(n - 1);
//}
//
//int main() {
//    int n;
//    printf("请输入n的值：");
//    scanf("%d", &n);
//    printf("%d\n", n, cubeSum(n));
//    return 0;
//}


//long fun(int n)
//{
//    int i;
//    long m;
//    m = 1;
//    for (i = 1; i <= n; i++)    m = m * i;
//    return m;
//}
//main()
//{
//    long m;
//    int k, n;
//    scanf("%d", &n);
//    m = 0;
//    for (k = 1; k <= n; k++)    m = m + fun(k);
//    printf("%ld\n", m);
//}

//写一个函数，使输入的一个字符串按反序，
//在主函数中输入字符串和，在非主函数中输出反序后的字符串。
//void reverseString(char str[]) {
//    int len = strlen(str);
//    for (int i = 0; i < len / 2; i++) {
//        char temp = str[i];
//        str[i] = str[len - i - 1];
//        str[len - i - 1] = temp;
//    }
//    printf("反序后的字符串：%s\n", str);
//}
//
//int main() {
//    char str[100];
//    printf("请输入字符串：");
//    scanf("%s", str);
//    reverseString(str);
//    return 0;
//}



//编写程序，证明100 - 200之间的所有偶数均可写成两个素数之和，并输出。
// 判断一个数是否为素数
//int isPrime(int n) {
//    if (n <= 1) return 0;
//    for (int i = 2; i * i <= n; i++) {
//        if (n % i == 0) return 0;
//    }
//    return 1;
//}
//
//int main() {
//    for (int even = 100; even <= 200; even += 2) {
//        int found = 0;
//        for (int prime1 = 2; prime1 <= even / 2; prime1++) {
//            if (isPrime(prime1) && isPrime(even - prime1)) {
//                printf("%d = %d + %d\n", even, prime1, even - prime1);
//                found = 1;
//                break;
//            }
//        }
//        if (!found) {
//            printf("%d 不能表示为两个素数之和\n", even);
//        }
//    }
//    return 0;
//}

//#include "stdio.h"
//void main()
//{
//    int a[] = { 2, 3, 4, 5, 6 };
//    int* p1;
//    char* p2 = "computer\n";
//
//    p1 = a;
//    printf("%d\n", p1 + 2);
//    printf("%d\n", *(p1 + 2));
//
//    p1 = a + 2;
//    printf("%d\n", p1 + 2);
//    printf("%d\n", *(p1 + 2));
//
//    printf(p2 + 2);
//    printf("%s", p2 + 2);
//}


#include <stdio.h>

//void main()
//{
//    char a[80], b[80], * p;
//    int i;
//
//    gets(a);
//    gets(b);
//
//    for (i = 0; i < 10; i++)
//    {
//        if (i % 2 == 0)
//            p = a;
//        else
//            p = b;
//        puts(p);
//    }
//}

//定义一个可以保存10个整型数的一维数组，
//用数组初始化的方法将10个数据（3，7，9，8，5，4，3，1，0，2）赋值到数组，
//用指针操作数组依次输出这十个数，再以逆序输出这十个数。
//int main() {
//    // 定义并初始化一维数组
//    int arr[10] = { 3, 7, 9, 8, 5, 4, 3, 1, 0, 2 };
//    // 定义指针指向数组首地址
//    int* p = arr;
//
//    // 依次输出数组元素
//    printf("正序输出：");
//    for (int i = 0; i < 10; i++) {
//        printf("%d ", *(p + i));
//    }
//    printf("\n");
//
//    // 逆序输出数组元素
//    printf("逆序输出：");
//    for (int i = 9; i >= 0; i--) {
//        printf("%d ", *(p + i));
//    }
//    printf("\n");
//
//    return 0;
//}

//从键盘输入的字符串有若干个数字字符，编写程序，
//用移动指针的方法将其中的数字字符取出(按自左向右的顺序)并组成一个整数，
//例如输入的字符串为12ab345c，则组成的整数为12345
//int main() {
//    // 定义存储输入字符串的数组
//    char str[100];
//    // 定义指针指向字符串
//    char* p;
//    // 用于存储组成的整数
//    int num = 0;
//
//    printf("请输入字符串：");
//    // 输入字符串
//    scanf("%s", str);
//    // 让指针指向字符串首地址
//    p = str;
//
//    // 遍历字符串
//    while (*p != '\0') {
//        // 判断是否为数字字符
//        if (*p >= '0' && *p <= '9') {
//            // 将数字字符转换为整数并累加到num中
//            num = num * 10 + (*p - '0');
//        }
//        // 指针后移一位
//        p++;
//    }
//
//    printf("组成的整数为：%d\n", num);
//
//    return 0;
//}


//void invert(int* s, int i, int j)
//{
//	int t;
//	if (i < j)
//	{
//		t = *(s + i);
//		*(s + i) = *(s + j);  // 交换s[i]和s[j]的值
//		*(s + j) = t;
//		invert(s, i + 1, j - 1);  // 递归处理下一对元素
//	}
//}
//void main()
//{
//	int a[10], i;
//	for (i = 0; i < 10; i++) scanf("%d", &a[i]);  // 输入数组元素
//	invert(a, 0, 10 - 1);
//	for (i = 0; i < 10; i++)
//		printf("%d ", a[i]);
//	printf("\n");
//}


//【附加题】写一个函数，实现两个字符串的比较。
//即写一个自己的strcmp1函数，函数的原型为：int strcmp1(char* p1, char* p2)
//设p1指向字符串s1，p2指向字符串s2。要求当s1 = s2时，返回值为0；若s1不等于s2，
//返回它们二者第一个不同字符的ASCⅡ码差值(如”BOY”与”BAD”，
//第二个字母不同，”O”与”A”之差为79 - 65 = 14)。如果s1 > s2，
//则输出正值，如果s1 < s2，则输出负值。)
//int strcmp1(char* p1, char* p2) {
//    // 循环比较两个字符串的字符，直到遇到不同字符或字符串结束（'\0'）
//    while (*p1 != '\0' && *p2 != '\0' && *p1 == *p2) {
//        p1++;
//        p2++;
//    }
//    // 返回第一个不同字符的 ASCII 码差值，若字符串相同则返回 0
//    return *p1 - *p2;
//}
//
//int main() {
//    char s1[100], s2[100];
//    printf("请输入第一个字符串：");
//    scanf("%s", s1);
//    printf("请输入第二个字符串：");
//    scanf("%s", s2);
//    int result = strcmp1(s1, s2);
//    printf("比较结果：%d\n", result);
//    return 0;
//}

//#include <stdio.h>
//#include <string.h>
//
//#define N 5  // 固定学生数量为5
//#define COURSE_NUM 3  // 固定课程数量为3
//
//// 定义学生结构体
//typedef struct Stu {
//    int num;               // 学号
//    char name[20];         // 姓名
//    char classname[20];    // 班级名称
//    float score[COURSE_NUM];  // 三门课程成绩（使用宏定义固定大小）
//    float aver_score;      // 平均分
//} STUDENT;
//
//// 输入学生数据函数
//void inputStudents(STUDENT stu[]) {
//    for (int i = 0; i < N; i++) {
//        printf("请输入第%d个学生信息（学号 班级 姓名 成绩1 成绩2 成绩3）：\n", i + 1);
//        scanf("%d %s %s %f %f %f",
//            &stu[i].num,
//            stu[i].classname,
//            stu[i].name,
//            &stu[i].score[0],
//            &stu[i].score[1],
//            &stu[i].score[2]);
//    }
//}
//
//// 计算每个学生的平均分
//void averageScore(STUDENT stu[]) {
//    for (int i = 0; i < N; i++) {
//        stu[i].aver_score = (stu[i].score[0] + stu[i].score[1] + stu[i].score[2]) / COURSE_NUM;
//    }
//}
//
//// 查找平均分最高的学生下标
//int maxAverageScore(STUDENT stu[]) {
//    int max_idx = 0;
//    for (int i = 1; i < N; i++) {
//        if (stu[i].aver_score > stu[max_idx].aver_score) {
//            max_idx = i;
//        }
//    }
//    return max_idx;
//}
//
//// 计算每门课程的平均分
//void courseAverage(STUDENT stu[], float course_avg[]) {
//    for (int j = 0; j < COURSE_NUM; j++) {
//        float sum = 0;
//        for (int i = 0; i < N; i++) {
//            sum += stu[i].score[j];
//        }
//        course_avg[j] = sum / N;
//    }
//}
//
//int main() {
//    STUDENT stu[N];        // 结构体数组（大小由宏N固定）
//    float course_avg[COURSE_NUM];  // 课程平均分数组（大小由宏COURSE_NUM固定）
//
//    inputStudents(stu);
//    averageScore(stu);
//    courseAverage(stu, course_avg);
//
//    // 输出每个学生的平均分
//    printf("\n每个学生的平均分：\n");
//    for (int i = 0; i < N; i++) {
//        printf("学号：%d  姓名：%s  平均分：%.2f\n",
//            stu[i].num,
//            stu[i].name,
//            stu[i].aver_score);
//    }
//
//    // 输出每门课程的平均分
//    printf("\n每门课程的平均分：\n");
//    for (int j = 0; j < COURSE_NUM; j++) {
//        printf("第%d门课程平均分：%.2f\n", j + 1, course_avg[j]);
//    }
//
//    // 输出平均分最高的学生信息
//    int max_idx = maxAverageScore(stu);
//    printf("\n平均分最高的学生信息：\n");
//    printf("学号：%d\n班级：%s\n姓名：%s\n",
//        stu[max_idx].num,
//        stu[max_idx].classname,
//        stu[max_idx].name);
//    printf("三门课成绩：%.2f, %.2f, %.2f\n平均分：%.2f\n",
//        stu[max_idx].score[0],
//        stu[max_idx].score[1],
//        stu[max_idx].score[2],
//        stu[max_idx].aver_score);
//
//    return 0;
//}


//采用结构体数组编写程序，定义一个含职工姓名、工作年限、工资总额的结构体类型，
//初始化5名职工的信息，最后再对工作年限超过30年的职工加100元工资，
//然后分别输出工资变化之前和之后的所有职工的信息。
//#include <stdio.h>
//#include <string.h>
//
//// 定义职工结构体类型
//typedef struct {
//    char name[20];    // 姓名
//    int work_years;   // 工作年限
//    float salary;     // 工资总额
//} Employee;
//
//// 输出职工信息函数
//void printEmployees(Employee emp[], int count) {
//    printf("姓名\t工作年限\t工资总额\n");
//    for (int i = 0; i < count; i++) {
//        printf("%s\t%d\t\t%.2f\n",
//            emp[i].name,
//            emp[i].work_years,
//            emp[i].salary);
//    }
//    printf("\n");
//}
//
//int main() {
//    // 初始化5名职工信息
//    Employee employees[5] = {
//        {"张三", 25, 5800.0f},
//        {"李四", 32, 6200.0f},
//        {"王五", 18, 4500.0f},
//        {"赵六", 35, 7100.0f},
//        {"钱七", 28, 5300.0f}
//    };
//    int count = 5;
//
//    // 输出工资变化前的信息
//    printf("工资调整前的职工信息：\n");
//    printEmployees(employees, count);
//
//    // 对工作年限超过30年的职工加100元工资
//    for (int i = 0; i < count; i++) {
//        if (employees[i].work_years > 30) {
//            employees[i].salary += 100;
//        }
//    }
//
//    // 输出工资变化后的信息
//    printf("工资调整后的职工信息：\n");
//    printEmployees(employees, count);
//
//    return 0;
//}
//
//#include <stdio.h>
//
//// 定义日期结构体
//struct Date {
//    int year;
//    int month;
//    int day;
//};
//
//// 判断是否为闰年
//int isLeapYear(int year) {
//    // 能被4整除且不能被100整除，或能被400整除的年份是闰年
//    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
//}
//
//// 计算该日期是本年的第几天
//int dayOfYear(struct Date d) {
//    // 非闰年每月天数
//    int daysInMonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//    int total = 0;
//    int i;
//
//    // 累加前几个月的天数
//    for (i = 0; i < d.month - 1; i++) {
//        total += daysInMonth[i];
//    }
//
//    // 加上当月天数
//    total += d.day;
//
//    // 若为闰年且月份大于2，加1天（2月多1天）
//    if (isLeapYear(d.year) && d.month > 2) {
//        total++;
//    }
//
//    return total;
//}
//
//int main() {
//    struct Date date;
//
//    // 输入日期
//    printf("请输入年 月 日（用空格分隔）：");
//    scanf("%d %d %d", &date.year, &date.month, &date.day);
//
//    // 计算并输出结果
//    printf("%d年%d月%d日是本年的第%d天\n",
//        date.year, date.month, date.day,
//        dayOfYear(date));
//
//    return 0;
//}